{
 "cells": [
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-05-29T06:50:22.753169Z",
     "start_time": "2025-05-29T06:50:15.983112Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# ==================== 1. 依赖库导入 ====================\n",
    "import os\n",
    "import re\n",
    "import nltk\n",
    "from nltk.corpus import stopwords\n",
    "from nltk.stem import WordNetLemmatizer\n",
    "from nltk.tokenize import word_tokenize\n",
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "from sklearn.linear_model import Perceptron, LogisticRegression\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.model_selection import train_test_split, GridSearchCV\n",
    "from sklearn.metrics import accuracy_score, classification_report\n"
   ],
   "id": "6cf9fd19af8aa5e9",
   "outputs": [],
   "execution_count": 1
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-05-29T06:59:37.808352Z",
     "start_time": "2025-05-29T06:50:22.769717Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# ==================== 2. 数据预处理 ====================\n",
    "nltk.download('stopwords')\n",
    "nltk.download('wordnet')\n",
    "nltk.download('punkt')\n",
    "\n",
    "def preprocess_text(text):\n",
    "    # 清洗特殊字符\n",
    "    text = re.sub(r'[^a-zA-Z\\s]', '', text)\n",
    "    # 文本标准化\n",
    "    text = text.lower()\n",
    "    words = word_tokenize(text)\n",
    "    # 停用词过滤\n",
    "    stop_words = set(stopwords.words('english'))\n",
    "    words = [word for word in words if word not in stop_words]\n",
    "    # 词形还原\n",
    "    lemmatizer = WordNetLemmatizer()\n",
    "    words = [lemmatizer.lemmatize(word) for word in words]\n",
    "    # 过滤短词\n",
    "    return \" \".join([word for word in words if len(word) > 2])\n"
   ],
   "id": "fd8644786d5228a3",
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[nltk_data] Error loading stopwords: Remote end closed connection\n",
      "[nltk_data]     without response\n",
      "[nltk_data] Error loading wordnet: Remote end closed connection\n",
      "[nltk_data]     without response\n",
      "[nltk_data] Downloading package punkt to\n",
      "[nltk_data]     C:\\Users\\15038\\AppData\\Roaming\\nltk_data...\n",
      "[nltk_data]   Package punkt is already up-to-date!\n"
     ]
    }
   ],
   "execution_count": 2
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-05-29T06:59:38.377918Z",
     "start_time": "2025-05-29T06:59:38.373884Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# ==================== 3. 数据加载 ====================\n",
    "def load_data(data_path):\n",
    "    texts = []\n",
    "    labels = []\n",
    "    for label in ['pos', 'neg']:\n",
    "        for split in ['train', 'test']:\n",
    "            path = os.path.join(data_path, split, label)\n",
    "            for file_name in os.listdir(path):\n",
    "                if file_name.endswith('.txt'):\n",
    "                    with open(os.path.join(path, file_name), 'r', encoding='utf-8') as file:\n",
    "                        texts.append(preprocess_text(file.read()))\n",
    "                        labels.append(1 if label == 'pos' else 0)\n",
    "    return texts, labels"
   ],
   "id": "aba577bd4f520497",
   "outputs": [],
   "execution_count": 3
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-05-29T07:02:47.412653Z",
     "start_time": "2025-05-29T06:59:38.382923Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# ==================== 4. 数据集划分 ====================\n",
    "data_path = 'D:/mytest/chenyajie/Moive/aclImdb'\n",
    "texts, labels = load_data(data_path)\n",
    "X_train, X_test, y_train, y_test = train_test_split(texts, labels, test_size=0.2, random_state=42)\n"
   ],
   "id": "6954a8edb20f1ead",
   "outputs": [],
   "execution_count": 4
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-05-29T07:02:57.050138Z",
     "start_time": "2025-05-29T07:02:47.505702Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# ==================== 5. 特征工程 ====================\n",
    "vectorizer = TfidfVectorizer()\n",
    "X_train_vec = vectorizer.fit_transform(X_train)\n",
    "X_test_vec = vectorizer.transform(X_test)"
   ],
   "id": "6b7e2dc9d06a1563",
   "outputs": [],
   "execution_count": 5
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-05-29T07:03:04.483163Z",
     "start_time": "2025-05-29T07:02:57.067690Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# ==================== 6. 模型训练与评估 ====================\n",
    "# -------------------- 6.1 感知机模型 --------------------\n",
    "import time\n",
    "from sklearn.linear_model import Perceptron\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.metrics import classification_report\n",
    "\n",
    "# 定义感知机模型的参数网格\n",
    "perceptron_param_grid = {\n",
    "    'alpha': [0.0001, 0.001, 0.01],\n",
    "    'max_iter': [500, 1000, 2000]\n",
    "}\n",
    "\n",
    "# 创建感知机模型\n",
    "perceptron = Perceptron()\n",
    "\n",
    "# 创建网格搜索对象\n",
    "perceptron_grid_search = GridSearchCV(perceptron, perceptron_param_grid, cv=3)\n",
    "\n",
    "# 记录开始时间\n",
    "start_time = time.time()\n",
    "\n",
    "# 模型训练\n",
    "perceptron_grid_search.fit(X_train_vec, y_train)\n",
    "\n",
    "# 记录结束时间\n",
    "end_time = time.time()\n",
    "\n",
    "# 获取最佳模型\n",
    "best_perceptron = perceptron_grid_search.best_estimator_\n",
    "\n",
    "# 预测\n",
    "y_pred_perceptron = best_perceptron.predict(X_test_vec)\n",
    "\n",
    "# 输出分类报告，并格式化小数点四位\n",
    "print(\"Perceptron Classification Report:\")\n",
    "report = classification_report(y_test, y_pred_perceptron, digits=4)\n",
    "print(report)\n",
    "\n",
    "# 计算训练时间\n",
    "training_time = end_time - start_time\n",
    "print(f\"Training Time: {training_time:.4f} seconds\")\n",
    "\n",
    "# 输出最佳参数\n",
    "print(f\"Best Parameters: {perceptron_grid_search.best_params_}\")"
   ],
   "id": "af55aba12b81d90c",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Perceptron Classification Report:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0     0.8827    0.8604    0.8714      4978\n",
      "           1     0.8650    0.8867    0.8757      5022\n",
      "\n",
      "    accuracy                         0.8736     10000\n",
      "   macro avg     0.8739    0.8735    0.8736     10000\n",
      "weighted avg     0.8738    0.8736    0.8736     10000\n",
      "\n",
      "Training Time: 7.3572 seconds\n",
      "Best Parameters: {'alpha': 0.0001, 'max_iter': 500}\n"
     ]
    }
   ],
   "execution_count": 6
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-05-29T07:03:19.908103Z",
     "start_time": "2025-05-29T07:03:04.517969Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# -------------------- 6.2 逻辑回归模型 --------------------\n",
    "import time\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.metrics import classification_report\n",
    "\n",
    "# 定义逻辑回归模型的参数网格\n",
    "logistic_param_grid = {\n",
    "    'C': [0.01, 0.1, 1],\n",
    "    'penalty': ['l1', 'l2'],\n",
    "    'solver': ['liblinear']\n",
    "}\n",
    "\n",
    "# 创建逻辑回归模型\n",
    "logistic = LogisticRegression(max_iter=1000)\n",
    "\n",
    "# 创建网格搜索对象\n",
    "logistic_grid_search = GridSearchCV(logistic, logistic_param_grid, cv=3)\n",
    "\n",
    "# 记录开始时间\n",
    "start_time = time.time()\n",
    "\n",
    "# 模型训练\n",
    "logistic_grid_search.fit(X_train_vec, y_train)\n",
    "\n",
    "# 记录结束时间\n",
    "end_time = time.time()\n",
    "\n",
    "# 获取最佳模型\n",
    "best_logistic = logistic_grid_search.best_estimator_\n",
    "\n",
    "# 预测\n",
    "y_pred_logistic = best_logistic.predict(X_test_vec)\n",
    "\n",
    "# 输出分类报告，并格式化小数点四位\n",
    "print(\"Logistic Regression Classification Report:\")\n",
    "report = classification_report(y_test, y_pred_logistic, digits=4)\n",
    "print(report)\n",
    "\n",
    "# 计算训练时间\n",
    "training_time = end_time - start_time\n",
    "print(f\"Training Time: {training_time:.4f} seconds\")\n",
    "\n",
    "# 输出最佳参数\n",
    "print(f\"Best Parameters: {logistic_grid_search.best_params_}\")"
   ],
   "id": "6a4abe9704b25606",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Logistic Regression Classification Report:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0     0.9080    0.8903    0.8991      4978\n",
      "           1     0.8933    0.9106    0.9019      5022\n",
      "\n",
      "    accuracy                         0.9005     10000\n",
      "   macro avg     0.9007    0.9005    0.9005     10000\n",
      "weighted avg     0.9006    0.9005    0.9005     10000\n",
      "\n",
      "Training Time: 15.3366 seconds\n",
      "Best Parameters: {'C': 1, 'penalty': 'l2', 'solver': 'liblinear'}\n"
     ]
    }
   ],
   "execution_count": 7
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-05-29T07:35:49.007130Z",
     "start_time": "2025-05-29T07:03:19.940335Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# -------------------- 6.3 优化后的SVM模型 --------------------\n",
    "import time\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.metrics import classification_report\n",
    "from sklearn.feature_selection import SelectKBest, chi2\n",
    "\n",
    "# 定义SVM模型的参数网格\n",
    "svm_param_grid = {\n",
    "    'C': [0.1, 1],\n",
    "    'kernel': ['linear'],  # 使用线性核\n",
    "    'gamma': ['scale']\n",
    "}\n",
    "\n",
    "# 创建SVM模型\n",
    "svm = SVC()\n",
    "\n",
    "# 创建网格搜索对象\n",
    "svm_grid_search = GridSearchCV(svm, svm_param_grid, cv=3)\n",
    "\n",
    "# 记录开始时间\n",
    "start_time = time.time()\n",
    "\n",
    "# 特征选择：选择最重要的1000个特征\n",
    "selector = SelectKBest(chi2, k=1000)\n",
    "X_train_vec_reduced = selector.fit_transform(X_train_vec, y_train)\n",
    "X_test_vec_reduced = selector.transform(X_test_vec)\n",
    "\n",
    "# 模型训练\n",
    "svm_grid_search.fit(X_train_vec_reduced, y_train)\n",
    "\n",
    "# 记录结束时间\n",
    "end_time = time.time()\n",
    "\n",
    "# 获取最佳模型\n",
    "best_svm = svm_grid_search.best_estimator_\n",
    "\n",
    "# 预测\n",
    "y_pred_svm = best_svm.predict(X_test_vec_reduced)\n",
    "\n",
    "# 输出分类报告，并格式化小数点四位\n",
    "print(\"SVM Classification Report:\")\n",
    "report = classification_report(y_test, y_pred_svm, digits=4)\n",
    "print(report)\n",
    "\n",
    "# 计算训练时间\n",
    "training_time = end_time - start_time\n",
    "print(f\"Training Time: {training_time:.4f} seconds\")\n",
    "\n",
    "# 输出最佳参数\n",
    "print(f\"Best Parameters: {svm_grid_search.best_params_}\")"
   ],
   "id": "a521de71543f0881",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SVM Classification Report:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0     0.8943    0.8648    0.8793      4978\n",
      "           1     0.8702    0.8986    0.8842      5022\n",
      "\n",
      "    accuracy                         0.8818     10000\n",
      "   macro avg     0.8822    0.8817    0.8817     10000\n",
      "weighted avg     0.8822    0.8818    0.8818     10000\n",
      "\n",
      "Training Time: 1902.2690 seconds\n",
      "Best Parameters: {'C': 1, 'gamma': 'scale', 'kernel': 'linear'}\n"
     ]
    }
   ],
   "execution_count": 8
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-05-29T07:35:50.289535Z",
     "start_time": "2025-05-29T07:35:49.108657Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# -------------------- 6.4 朴素贝叶斯模型 --------------------\n",
    "import time\n",
    "from sklearn.naive_bayes import MultinomialNB\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.metrics import classification_report\n",
    "\n",
    "# 定义朴素贝叶斯模型的参数网格\n",
    "nb_param_grid = {\n",
    "    'alpha': [0.01, 0.1, 1],\n",
    "    'fit_prior': [True, False]\n",
    "}\n",
    "\n",
    "# 创建朴素贝叶斯模型\n",
    "nb = MultinomialNB()\n",
    "\n",
    "# 创建网格搜索对象\n",
    "nb_grid_search = GridSearchCV(nb, nb_param_grid, cv=3)\n",
    "\n",
    "# 记录开始时间\n",
    "start_time = time.time()\n",
    "\n",
    "# 模型训练\n",
    "nb_grid_search.fit(X_train_vec, y_train)\n",
    "\n",
    "# 记录结束时间\n",
    "end_time = time.time()\n",
    "\n",
    "# 获取最佳模型\n",
    "best_nb = nb_grid_search.best_estimator_\n",
    "\n",
    "# 预测\n",
    "y_pred_nb = best_nb.predict(X_test_vec)\n",
    "\n",
    "# 输出分类报告，并格式化小数点四位\n",
    "print(\"Naive Bayes Classification Report:\")\n",
    "report = classification_report(y_test, y_pred_nb, digits=4)\n",
    "print(report)\n",
    "\n",
    "# 计算训练时间\n",
    "training_time = end_time - start_time\n",
    "print(f\"Training Time: {training_time:.4f} seconds\")\n",
    "\n",
    "# 输出最佳参数\n",
    "print(f\"Best Parameters: {nb_grid_search.best_params_}\")"
   ],
   "id": "59a7cd2fc7993138",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Naive Bayes Classification Report:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0     0.8561    0.8867    0.8711      4978\n",
      "           1     0.8836    0.8523    0.8676      5022\n",
      "\n",
      "    accuracy                         0.8694     10000\n",
      "   macro avg     0.8698    0.8695    0.8694     10000\n",
      "weighted avg     0.8699    0.8694    0.8694     10000\n",
      "\n",
      "Training Time: 1.1348 seconds\n",
      "Best Parameters: {'alpha': 1, 'fit_prior': False}\n"
     ]
    }
   ],
   "execution_count": 9
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-05-29T07:37:35.841059Z",
     "start_time": "2025-05-29T07:35:50.300066Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# ==================== 6.5 决策树模型优化 ====================\n",
    "import time\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.model_selection import RandomizedSearchCV\n",
    "from sklearn.metrics import classification_report\n",
    "\n",
    "# 定义决策树模型的参数网格\n",
    "dt_param_grid = {\n",
    "    'criterion': ['gini', 'entropy'],\n",
    "    'max_depth': [None, 10, 30],\n",
    "    'min_samples_split': [2, 10],\n",
    "    'min_samples_leaf': [1, 4]\n",
    "}\n",
    "\n",
    "# 创建决策树模型\n",
    "dt = DecisionTreeClassifier(random_state=42)\n",
    "\n",
    "# 创建随机搜索对象，设置 n_iter=10，cv=2，并行化计算\n",
    "dt_random_search = RandomizedSearchCV(dt, dt_param_grid, n_iter=10, cv=2, n_jobs=-1, random_state=42)\n",
    "\n",
    "# 记录开始时间\n",
    "start_time = time.time()\n",
    "\n",
    "# 模型训练\n",
    "dt_random_search.fit(X_train_vec, y_train)\n",
    "\n",
    "# 记录结束时间\n",
    "end_time = time.time()\n",
    "\n",
    "# 获取最佳模型\n",
    "best_dt = dt_random_search.best_estimator_\n",
    "\n",
    "# 预测\n",
    "y_pred_dt = best_dt.predict(X_test_vec)\n",
    "\n",
    "# 输出分类报告，并格式化小数点四位\n",
    "print(\"Decision Tree Classification Report:\")\n",
    "report = classification_report(y_test, y_pred_dt, digits=4)\n",
    "print(report)\n",
    "\n",
    "# 计算训练时间\n",
    "training_time = end_time - start_time\n",
    "print(f\"Training Time: {training_time:.4f} seconds\")\n",
    "\n",
    "# 输出最佳参数\n",
    "print(f\"Best Parameters: {dt_random_search.best_params_}\")"
   ],
   "id": "63d572bb97ae5426",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Decision Tree Classification Report:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0     0.7632    0.6902    0.7249      4978\n",
      "           1     0.7195    0.7877    0.7521      5022\n",
      "\n",
      "    accuracy                         0.7392     10000\n",
      "   macro avg     0.7414    0.7390    0.7385     10000\n",
      "weighted avg     0.7413    0.7392    0.7386     10000\n",
      "\n",
      "Training Time: 105.2679 seconds\n",
      "Best Parameters: {'min_samples_split': 10, 'min_samples_leaf': 4, 'max_depth': 30, 'criterion': 'gini'}\n"
     ]
    }
   ],
   "execution_count": 10
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-05-29T07:48:16.283135Z",
     "start_time": "2025-05-29T07:37:35.909910Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# -------------------- 6.6 K近邻模型 --------------------\n",
    "import time\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.metrics import classification_report\n",
    "\n",
    "# 定义K近邻模型的参数网格\n",
    "knn_param_grid = {\n",
    "    'n_neighbors': [3, 5, 7, 9],\n",
    "    'weights': ['uniform', 'distance'],\n",
    "    'algorithm': ['brute']  # 显式指定使用brute算法\n",
    "}\n",
    "\n",
    "# 创建K近邻模型\n",
    "knn = KNeighborsClassifier()\n",
    "\n",
    "# 创建网格搜索对象\n",
    "knn_grid_search = GridSearchCV(knn, knn_param_grid, cv=3)\n",
    "\n",
    "# 记录开始时间\n",
    "start_time = time.time()\n",
    "\n",
    "# 模型训练\n",
    "knn_grid_search.fit(X_train_vec, y_train)\n",
    "\n",
    "# 记录结束时间\n",
    "end_time = time.time()\n",
    "\n",
    "# 获取最佳模型\n",
    "best_knn = knn_grid_search.best_estimator_\n",
    "\n",
    "# 预测\n",
    "y_pred_knn = best_knn.predict(X_test_vec)\n",
    "\n",
    "# 输出分类报告，并格式化小数点四位\n",
    "print(\"K-Nearest Neighbors Classification Report:\")\n",
    "report = classification_report(y_test, y_pred_knn, digits=4)\n",
    "print(report)\n",
    "\n",
    "# 计算训练时间\n",
    "training_time = end_time - start_time\n",
    "print(f\"Training Time: {training_time:.4f} seconds\")\n",
    "\n",
    "# 输出最佳参数\n",
    "print(f\"Best Parameters: {knn_grid_search.best_params_}\")"
   ],
   "id": "3b4614cb50aa39e2",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "K-Nearest Neighbors Classification Report:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0     0.8289    0.7121    0.7661      4978\n",
      "           1     0.7496    0.8542    0.7985      5022\n",
      "\n",
      "    accuracy                         0.7835     10000\n",
      "   macro avg     0.7892    0.7832    0.7823     10000\n",
      "weighted avg     0.7891    0.7835    0.7824     10000\n",
      "\n",
      "Training Time: 615.5869 seconds\n",
      "Best Parameters: {'algorithm': 'brute', 'n_neighbors': 9, 'weights': 'distance'}\n"
     ]
    }
   ],
   "execution_count": 11
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-05-29T07:50:46.895325Z",
     "start_time": "2025-05-29T07:50:46.855578Z"
    }
   },
   "cell_type": "code",
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from sklearn.metrics import confusion_matrix\n",
    "\n",
    "# ==================== 7. 可视化 ====================\n",
    "# 获取各模型的准确率和训练时间\n",
    "models = ['Perceptron', 'Logistic Regression', 'SVM', 'Naive Bayes', 'Decision Tree', 'K-Nearest Neighbors']\n",
    "accuracies = [\n",
    "    accuracy_score(y_test, y_pred_perceptron),\n",
    "    accuracy_score(y_test, y_pred_logistic),\n",
    "    accuracy_score(y_test, y_pred_svm),\n",
    "    accuracy_score(y_test, y_pred_nb),\n",
    "    accuracy_score(y_test, y_pred_dt),\n",
    "    accuracy_score(y_test, y_pred_knn)\n",
    "]\n",
    "training_times = [\n",
    "    perceptron_grid_search.refit_time_,\n",
    "    logistic_grid_search.refit_time_,\n",
    "    svm_grid_search.refit_time_,\n",
    "    nb_grid_search.refit_time_,\n",
    "    dt_random_search.refit_time_,\n",
    "    knn_grid_search.refit_time_\n",
    "]"
   ],
   "id": "205fdf01524ea8ec",
   "outputs": [],
   "execution_count": 13
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-05-29T07:51:13.334993Z",
     "start_time": "2025-05-29T07:51:13.203968Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 绘制准确率柱状图\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.bar(models, accuracies, color='skyblue')\n",
    "plt.xlabel('Model')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.title('Model Accuracy Comparison')\n",
    "plt.ylim(0, 1)  # 限制y轴范围在0到1之间\n",
    "for i, v in enumerate(accuracies):\n",
    "    plt.text(i, v + 0.01, str(round(v, 4)), ha='center')  # 在柱子上方显示准确率值\n",
    "plt.show()"
   ],
   "id": "37a441c1949292dd",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 14
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-05-29T07:51:39.423253Z",
     "start_time": "2025-05-29T07:51:39.297137Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 绘制训练时间柱状图\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.bar(models, training_times, color='lightgreen')\n",
    "plt.xlabel('Model')\n",
    "plt.ylabel('Training Time (seconds)')\n",
    "plt.title('Model Training Time Comparison')\n",
    "for i, v in enumerate(training_times):\n",
    "    plt.text(i, v + 0.01, str(round(v, 4)), ha='center')  # 在柱子上方显示训练时间值\n",
    "plt.show()"
   ],
   "id": "2449ee442c8eb0b3",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 15
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-05-29T07:52:29.170962Z",
     "start_time": "2025-05-29T07:52:28.975680Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 绘制SVM混淆矩阵\n",
    "svm_conf_matrix = confusion_matrix(y_test, y_pred_svm)\n",
    "plt.figure(figsize=(8, 6))\n",
    "sns.heatmap(svm_conf_matrix, annot=True, fmt='d', cmap='Blues',\n",
    "            xticklabels=['Negative', 'Positive'], yticklabels=['Negative', 'Positive'])\n",
    "plt.xlabel('Predicted Label')\n",
    "plt.ylabel('True Label')\n",
    "plt.title('SVM Confusion Matrix')\n",
    "plt.show()"
   ],
   "id": "fd3b35178ffe5152",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 800x600 with 2 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 16
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-05-29T07:58:05.336628Z",
     "start_time": "2025-05-29T07:58:05.040794Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 提取各模型的召回率\n",
    "recalls = [\n",
    "    classification_report(y_test, y_pred_perceptron, output_dict=True)['1']['recall'],\n",
    "    classification_report(y_test, y_pred_logistic, output_dict=True)['1']['recall'],\n",
    "    classification_report(y_test, y_pred_svm, output_dict=True)['1']['recall'],\n",
    "    classification_report(y_test, y_pred_nb, output_dict=True)['1']['recall'],\n",
    "    classification_report(y_test, y_pred_dt, output_dict=True)['1']['recall'],\n",
    "    classification_report(y_test, y_pred_knn, output_dict=True)['1']['recall']\n",
    "]\n",
    "\n",
    "# 绘制召回率柱状图\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.bar(models, recalls, color='lightcoral')\n",
    "plt.xlabel('Model')\n",
    "plt.ylabel('Recall')\n",
    "plt.title('Model Recall Comparison')\n",
    "plt.ylim(0, 1)  # 限制y轴范围在0到1之间\n",
    "for i, v in enumerate(recalls):\n",
    "    plt.text(i, v + 0.01, str(round(v, 4)), ha='center')  # 在柱子上方显示召回率值\n",
    "plt.show()"
   ],
   "id": "720c1d8c2221bf4",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 18
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-05-29T07:58:17.009129Z",
     "start_time": "2025-05-29T07:58:16.782173Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 提取各模型的F1分数\n",
    "f1_scores = [\n",
    "    classification_report(y_test, y_pred_perceptron, output_dict=True)['1']['f1-score'],\n",
    "    classification_report(y_test, y_pred_logistic, output_dict=True)['1']['f1-score'],\n",
    "    classification_report(y_test, y_pred_svm, output_dict=True)['1']['f1-score'],\n",
    "    classification_report(y_test, y_pred_nb, output_dict=True)['1']['f1-score'],\n",
    "    classification_report(y_test, y_pred_dt, output_dict=True)['1']['f1-score'],\n",
    "    classification_report(y_test, y_pred_knn, output_dict=True)['1']['f1-score']\n",
    "]\n",
    "\n",
    "# 绘制F1分数柱状图\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.bar(models, f1_scores, color='lightblue')\n",
    "plt.xlabel('Model')\n",
    "plt.ylabel('F1 Score')\n",
    "plt.title('Model F1 Score Comparison')\n",
    "plt.ylim(0, 1)  # 限制y轴范围在0到1之间\n",
    "for i, v in enumerate(f1_scores):\n",
    "    plt.text(i, v + 0.01, str(round(v, 4)), ha='center')  # 在柱子上方显示F1分数值\n",
    "plt.show()"
   ],
   "id": "e47c3d2279e4df4e",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 19
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-05-29T07:58:35.423573Z",
     "start_time": "2025-05-29T07:58:35.096127Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 提取各模型的精确率\n",
    "precisions = [\n",
    "    classification_report(y_test, y_pred_perceptron, output_dict=True)['1']['precision'],\n",
    "    classification_report(y_test, y_pred_logistic, output_dict=True)['1']['precision'],\n",
    "    classification_report(y_test, y_pred_svm, output_dict=True)['1']['precision'],\n",
    "    classification_report(y_test, y_pred_nb, output_dict=True)['1']['precision'],\n",
    "    classification_report(y_test, y_pred_dt, output_dict=True)['1']['precision'],\n",
    "    classification_report(y_test, y_pred_knn, output_dict=True)['1']['precision']\n",
    "]\n",
    "\n",
    "# 绘制精确率柱状图\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.bar(models, precisions, color='lightgreen')\n",
    "plt.xlabel('Model')\n",
    "plt.ylabel('Precision')\n",
    "plt.title('Model Precision Comparison')\n",
    "plt.ylim(0, 1)  # 限制y轴范围在0到1之间\n",
    "for i, v in enumerate(precisions):\n",
    "    plt.text(i, v + 0.01, str(round(v, 4)), ha='center')  # 在柱子上方显示精确率值\n",
    "plt.show()"
   ],
   "id": "16a3ba803fb155f8",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 20
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-05-29T08:00:05.835605Z",
     "start_time": "2025-05-29T07:58:49.627847Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from sklearn.metrics import roc_curve, auc\n",
    "\n",
    "# 获取各模型的ROC曲线数据\n",
    "y_pred_perceptron_prob = best_perceptron.decision_function(X_test_vec)\n",
    "y_pred_logistic_prob = best_logistic.predict_proba(X_test_vec)[:, 1]\n",
    "y_pred_svm_prob = best_svm.decision_function(X_test_vec_reduced)\n",
    "y_pred_nb_prob = best_nb.predict_proba(X_test_vec)[:, 1]\n",
    "y_pred_dt_prob = best_dt.predict_proba(X_test_vec)[:, 1]\n",
    "y_pred_knn_prob = best_knn.predict_proba(X_test_vec)[:, 1]\n",
    "\n",
    "# 计算各模型的ROC曲线\n",
    "fpr_perceptron, tpr_perceptron, _ = roc_curve(y_test, y_pred_perceptron_prob)\n",
    "fpr_logistic, tpr_logistic, _ = roc_curve(y_test, y_pred_logistic_prob)\n",
    "fpr_svm, tpr_svm, _ = roc_curve(y_test, y_pred_svm_prob)\n",
    "fpr_nb, tpr_nb, _ = roc_curve(y_test, y_pred_nb_prob)\n",
    "fpr_dt, tpr_dt, _ = roc_curve(y_test, y_pred_dt_prob)\n",
    "fpr_knn, tpr_knn, _ = roc_curve(y_test, y_pred_knn_prob)\n",
    "\n",
    "# 计算各模型的AUC值\n",
    "roc_auc_perceptron = auc(fpr_perceptron, tpr_perceptron)\n",
    "roc_auc_logistic = auc(fpr_logistic, tpr_logistic)\n",
    "roc_auc_svm = auc(fpr_svm, tpr_svm)\n",
    "roc_auc_nb = auc(fpr_nb, tpr_nb)\n",
    "roc_auc_dt = auc(fpr_dt, tpr_dt)\n",
    "roc_auc_knn = auc(fpr_knn, tpr_knn)\n",
    "\n",
    "# 绘制多模型ROC曲线对比图\n",
    "plt.figure(figsize=(10, 8))\n",
    "plt.plot(fpr_perceptron, tpr_perceptron, label=f'Perceptron (AUC = {roc_auc_perceptron:.4f})', color='blue')\n",
    "plt.plot(fpr_logistic, tpr_logistic, label=f'Logistic Regression (AUC = {roc_auc_logistic:.4f})', color='orange')\n",
    "plt.plot(fpr_svm, tpr_svm, label=f'SVM (AUC = {roc_auc_svm:.4f})', color='green')\n",
    "plt.plot(fpr_nb, tpr_nb, label=f'Naive Bayes (AUC = {roc_auc_nb:.4f})', color='red')\n",
    "plt.plot(fpr_dt, tpr_dt, label=f'Decision Tree (AUC = {roc_auc_dt:.4f})', color='purple')\n",
    "plt.plot(fpr_knn, tpr_knn, label=f'K-Nearest Neighbors (AUC = {roc_auc_knn:.4f})', color='brown')\n",
    "plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')\n",
    "plt.xlim([0.0, 1.0])\n",
    "plt.ylim([0.0, 1.05])\n",
    "plt.xlabel('False Positive Rate')\n",
    "plt.ylabel('True Positive Rate')\n",
    "plt.title('ROC Curve Comparison')\n",
    "plt.legend(loc=\"lower right\")\n",
    "plt.show()"
   ],
   "id": "1a2a37ed8407d155",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1000x800 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 21
  }
 ],
 "metadata": {
  "kernelspec": {
   "name": "python3",
   "language": "python",
   "display_name": "Python 3 (ipykernel)"
  }
 },
 "nbformat": 5,
 "nbformat_minor": 9
}
